# Sample utterances for OrderPizza intent
I want to order a pizza
Can I get a pizza please
Order me a {PizzaSize} pizza
I'd like a {PizzaSize} {CrustType} crust pizza
Get me a pizza with {Toppings}
I want a large pizza with extra cheese
Place a pizza order for me
Can you order a medium thin crust pizza
I'd like to place a pizza order
One pizza please

# Slot Type: PizzaSizeType
Type:   Custom slot type (Expand values)
Values:
  - Small  (synonyms: sm, personal)
  - Medium (synonyms: med, regular)
  - Large  (synonyms: lg, big, family)
  - Extra Large (synonyms: XL, extra-large)

# Slot Type: CrustType
Values:
  - Thin      (synonyms: thin-crust, crispy)
  - Thick     (synonyms: deep-dish, pan)
  - Stuffed   (synonyms: cheese-stuffed)
  - Gluten-free

# Slot Type: ToppingType (AMAZON.AlphaNumeric also works)
Values:
  - Cheese, Pepperoni, Mushrooms, Onions
  - Olives, Peppers, Bacon, Pineapple

Confirmation prompt:
"Just to confirm: a {PizzaSize} pizza with {CrustType} crust"
"and {Toppings}. Shall I place this order?"

Decline response:
"No problem, order cancelled. Let me know if you'd like anything else."

You:  I want a pizza
Bot:  What size pizza would you like?
You:  Large
Bot:  What type of crust would you like?
You:  Thin crust
Bot:  What toppings would you like?
You:  Pepperoni and mushrooms
Bot:  Just to confirm: a Large pizza with Thin crust and Pepperoni and mushrooms. Shall I place this order?
You:  Yes
Bot:  [Fulfillment response]

# ❌ BAD - Too similar, low diversity
I want to book a flight
I would like to book a flight
Book me a flight

# ✅ GOOD - Structural variety
I want to book a flight
Can I get a ticket to {Destination}
Book me a {CabinClass} seat on {Date}
What flights are available to {Destination}
I need to fly to {Destination} on {Date}
Get me on a flight to {Destination}
Reserve a seat for me
I'd like to make a flight reservation
Schedule a flight for next {Date}
{Destination} please, flying {Date}

# Enable in console: Bot Settings > Clarification
Clarification prompt:
"I'm not sure what you mean. Did you want to (1) check order status or (2) place a new order?"
Max clarification retries: 2
If still unclear: trigger FallbackIntent

# In Lex Console: Intent > Closing response
Message: "Your {PizzaSize} pizza has been ordered! ETA: 30 minutes. Enjoy! 🍕"

# You can also use session attributes in messages:
Message: "Order #{orderRef} confirmed for {CustomerName}. Check your email for details."

# Slot configuration in Lex console
Slot: DepartureCity
Type: AMAZON.City
Required: true

Prompts:
  "Which city are you flying from?"
  "What's your departure city?"      # Retry 1
  "Please tell me where you're departing from."  # Retry 2

Max retries: 2
If still not filled: Close with failure response

import json

def lambda_handler(event, context):
    invocation_source = event['invocationSource']
    
    if invocation_source == 'DialogCodeHook':
        # Validate slots on every turn
        slots = event['sessionState']['intent']['slots']
        pizza_size = slots.get('PizzaSize')
        
        if pizza_size and pizza_size['value']['interpretedValue'] not in ['Small','Medium','Large']:
            # Invalid value — re-elicit the slot
            return elicit_slot(event, 'PizzaSize', 
                "Sorry, we only have Small, Medium, or Large. Which would you like?")
        
        # All good — delegate back to Lex
        return delegate(event)
    
    elif invocation_source == 'FulfillmentCodeHook':
        return fulfill_order(event)


def elicit_slot(event, slot_name, message):
    return {
        'sessionState': {
            'dialogAction': {'type': 'ElicitSlot', 'slotToElicit': slot_name},
            'intent': event['sessionState']['intent']
        },
        'messages': [{'contentType': 'PlainText', 'content': message}]
    }

def delegate(event):
    return {
        'sessionState': {
            'dialogAction': {'type': 'Delegate'},
            'intent': event['sessionState']['intent']
        }
    }

{
  "sessionId": "user-abc-123",
  "invocationSource": "FulfillmentCodeHook",  // or "DialogCodeHook"
  "inputTranscript": "Large pepperoni thin crust please",
  "sessionState": {
    "intent": {
      "name": "OrderPizza",
      "state": "ReadyForFulfillment",
      "slots": {
        "PizzaSize": {
          "value": {
            "originalValue": "large",
            "interpretedValue": "Large",
            "resolvedValues": ["Large"]
          }
        },
        "CrustType": {
          "value": {"interpretedValue": "Thin"}
        },
        "Toppings": {
          "value": {"interpretedValue": "Pepperoni"}
        }
      }
    },
    "sessionAttributes": {
      "userId": "user-abc-123"
    }
  }
}

import json
import boto3
from datetime import datetime
import uuid

dynamodb = boto3.resource('dynamodb')
orders_table = dynamodb.Table('PizzaOrders')

def lambda_handler(event, context):
    source = event['invocationSource']
    
    if source == 'FulfillmentCodeHook':
        slots = event['sessionState']['intent']['slots']
        
        # Extract slot values safely
        def get_slot(name):
            s = slots.get(name)
            return s['value']['interpretedValue'] if s else None
        
        size    = get_slot('PizzaSize')
        crust   = get_slot('CrustType')
        toppings = get_slot('Toppings') or 'Cheese only'
        
        # Generate order ID and save to DynamoDB
        order_id = str(uuid.uuid4())[:8].upper()
        orders_table.put_item(Item={
            'orderId': order_id,
            'size': size,
            'crust': crust,
            'toppings': toppings,
            'timestamp': datetime.utcnow().isoformat(),
            'status': 'confirmed'
        })
        
        message = f"Order #{order_id} confirmed! " \
                  f"Your {size} {crust} crust pizza with {toppings} " \
                  "will be ready in ~25 minutes."
        
        return close_intent(event, message, 'Fulfilled')
    
    return close_intent(event, "Something went wrong. Please try again.", 'Failed')


def close_intent(event, message, state):
    intent = event['sessionState']['intent']
    intent['state'] = state
    return {
        'sessionState': {
            'dialogAction': {'type': 'Close'},
            'intent': intent,
            'sessionAttributes': event['sessionState'].get('sessionAttributes', {})
        },
        'messages': [{'contentType': 'PlainText', 'content': message}]
    }

# Lambda: Set a session attribute
session_attrs = event['sessionState'].get('sessionAttributes', {})
session_attrs['customerTier'] = 'GOLD'
session_attrs['cartTotal'] = '29.99'

# Return with updated session attributes
return {
    'sessionState': {
        'dialogAction': {'type': 'Delegate'},
        'intent': event['sessionState']['intent'],
        'sessionAttributes': session_attrs   # ← persisted!
    }
}

# Lambda: switch to a different intent
return {
    'sessionState': {
        'dialogAction': {'type': 'ElicitIntent'},
        'intent': {'name': 'CheckOrderStatus'},  # jump here
        'sessionAttributes': session_attrs
    },
    'messages': [{
        'contentType': 'PlainText',
        'content': 'Sure! Let me check your order status. What\\'s your order number?'
    }]
}

// Install: npm install @aws-sdk/client-lex-runtime-v2
import { LexRuntimeV2Client, RecognizeTextCommand } from "@aws-sdk/client-lex-runtime-v2";

const client = new LexRuntimeV2Client({
  region: "us-east-1",
  credentials: cognitoCredentials  // from Cognito Identity Pool
});

async function sendMessage(text) {
  const command = new RecognizeTextCommand({
    botId: "YOUR_BOT_ID",
    botAliasId: "TSTALIASID",  // or your alias
    localeId: "en_US",
    sessionId: "user-session-123",
    text: text
  });
  
  const response = await client.send(command);
  const reply = response.messages?.[0]?.content;
  console.log("Bot says:", reply);
  return reply;
}

// Usage
sendMessage("I want to order a large pizza");

# Amazon Connect Contact Flow snippet (JSON)
{
  "Type": "GetParticipantInput",
  "Parameters": {
    "Text": "Welcome to PizzaBot! How can I help you today?",
    "LexV2Bot": {
      "AliasArn": "arn:aws:lex:us-east-1:123456789:bot-alias/BOTID/ALIASID"
    }
  }
}

# Lambda proxy to Lex (keeps credentials server-side)
import boto3, json

lex = boto3.client('lexv2-runtime', region_name='us-east-1')

def lambda_handler(event, context):
    body = json.loads(event['body'])
    
    response = lex.recognize_text(
        botId='YOUR_BOT_ID',
        botAliasId='YOUR_ALIAS_ID',
        localeId='en_US',
        sessionId=body['sessionId'],
        text=body['message']
    )
    
    reply = response['messages'][0]['content'] if response.get('messages') else ''
    
    return {
        'statusCode': 200,
        'headers': {'Access-Control-Allow-Origin': '*'},
        'body': json.dumps({'reply': reply})
    }

# Example missed utterances to review:
"gimme a pizza"         → Add to OrderPizza
"what's in my cart"     → Add to CheckCart intent
"cancel that"           → Add to CancelOrder
"speak to a person"     → Add to EscalateToAgent

# Test a Lex bot via AWS CLI
aws lexv2-runtime recognize-text \
  --bot-id YOUR_BOT_ID \
  --bot-alias-id TSTALIASID \
  --locale-id en_US \
  --session-id test-session-001 \
  --text "I want a large pepperoni pizza"

# Response shows intent + slots:
{
  "sessionId": "test-session-001",
  "messages": [{"content": "What type of crust would you like?"}],
  "sessionState": {
    "intent": {
      "name": "OrderPizza",
      "state": "InProgress",
      "slots": {
        "PizzaSize": {"value": {"interpretedValue": "Large"}},
        "Toppings": {"value": {"interpretedValue": "Pepperoni"}},
        "CrustType": null  # still being elicited
      }
    }
  }
}

import boto3, json

lex = boto3.client('lexv2-runtime')

test_cases = [
    {"input": "I want a pizza", "expected_intent": "OrderPizza"},
    {"input": "What's my order status", "expected_intent": "CheckOrderStatus"},
    {"input": "gibberish xyz 123", "expected_intent": "FallbackIntent"},
]

for i, test in enumerate(test_cases):
    resp = lex.recognize_text(
        botId='YOUR_BOT_ID', botAliasId='TSTALIASID',
        localeId='en_US', sessionId=f'test-{i}',
        text=test['input']
    )
    actual = resp['sessionState']['intent']['name']
    status = '✅ PASS' if actual == test['expected_intent'] else '❌ FAIL'
    print(f"{status} | '{test['input']}' → {actual}")

import boto3, json

dynamodb = boto3.resource('dynamodb')
sns = boto3.client('sns')
accounts = dynamodb.Table('BankAccounts')

def lambda_handler(event, context):
    intent_name = event['sessionState']['intent']['name']
    source = event['invocationSource']
    slots = event['sessionState']['intent'].get('slots', {})
    session = event['sessionState'].get('sessionAttributes', {})
    
    def get_slot(name):
        s = slots.get(name)
        return s['value']['interpretedValue'] if s else None
    
    if intent_name == 'CheckBalance' and source == 'FulfillmentCodeHook':
        user_id = session.get('userId', 'demo-user')
        acct_type = get_slot('AccountType') or 'checking'
        
        # Look up balance
        result = accounts.get_item(Key={'userId': user_id, 'accountType': acct_type})
        balance = result.get('Item', {}).get('balance', 'N/A')
        
        return close(event, f"Your {acct_type} balance is ${balance:,.2f}.")
    
    elif intent_name == 'ReportFraud' and source == 'FulfillmentCodeHook':
        card = get_slot('CardLast4')
        # Send SNS alert to fraud team
        sns.publish(
            TopicArn='arn:aws:sns:us-east-1:123456789:FraudAlerts',
            Subject=f'Fraud Report - Card ending {card}',
            Message=json.dumps({'userId': session.get('userId'), 'card': card})
        )
        return close(event, 
            f"Fraud report filed for card ending {card}. "
            "Your card has been blocked. A specialist will contact you within 2 hours.")
    
    elif intent_name == 'TransferFunds' and source == 'FulfillmentCodeHook':
        amount = get_slot('Amount')
        from_acct = get_slot('FromAccount')
        to_acct = get_slot('ToAccount')
        # Real transfer logic goes here
        return close(event, f"${amount} transferred from {from_acct} to {to_acct}. Done! ✅")
    
    return close(event, "I'm not sure how to help with that. Type 'agent' to speak with someone.")


def close(event, message):
    intent = event['sessionState']['intent']
    intent['state'] = 'Fulfilled'
    return {
        'sessionState': {
            'dialogAction': {'type': 'Close'},
            'intent': intent,
            'sessionAttributes': event['sessionState'].get('sessionAttributes', {})
        },
        'messages': [{'contentType': 'PlainText', 'content': message}]
    }